package com.sunni.test;

import org.junit.Test;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class WeekedHomework {


    /*
1， JDK和JRE的区别？
    // jdk包括jre。jre是虚拟机+运行环境，jdk：jre+声明+源代码。
2， 解释名称 JVM
    // java虚拟机，.java --> .class。
3， 描述java代码的运行过程，解释java跨平台。
    // .java --> .class --> cpu执行
4， Java中的三种注释分别是什么？语法是什么？
    //  '//'单行注释 '\/**\/'多行注释   '\/***\/'文档注释
5， Java中标识符的命名规则
    // 英文区分大小写，可以_打头，不能数字、$打头，推荐驼峰命名。
6， 解释变量，常量的概念
    // 变量：值可以改变。
    // 常量：final修饰，值不可变。
7， 解释成员变量，局部变量。
    // 成员变量：对象可以调用，在堆里。局部变量：在栈的方法里。
8， 描述java中8大基本数据类型
    // byte short int long float double char boolean
9， 解释自动类型转换和强制类型转换
    // 自动：字节小 转 字节大。低转高。
    // 强制：字节大 转 字节小。高转低。
10， 解释短路与，短路或。
    // 与：and &&  ，多个表达式，一个false，返回值为false.
    // 与：or ||  ，多个表达式，一个true，返回值为true.
11， While 和do while的区别
    // while(表达式): 先做表达式计算，true进入循环。
    // do_while(表达式)：第一遍直接执行，第二遍再做表达式运算。
12， 解释方法的形参，实参。
    //形参：定义方法时 要求方法被调用时需传进去的参数。实参：调用方法时，实际传进去的参数。
13， 面向对象是什么？面向过程与面向对象的区别
    // 面向对象：见名知意，就是 面朝着女朋友。
14， 解释类，对象。
    // 类是抽象的，取多个对象的共同属性组成类。对象是类的实例化。
15， 解释构造方法 及其特点。
    // new 一个对象的时候就是调用对象所属类的构造器。构造器可以重造，从而创建对象时，可以调用不同构造器。

     */


    /*

    1， 创建两个变量a、b，给它们赋值，书写代码，将a，b的值交换。
    2， 给你一个年份，判断该年份是不是闰年。
    3， 从控制台上输入两个数，将较大的数输出。
    4， 求1-100的累加值和。
    5， 求1-10的累乘
    6， * 输出1000以内的素数
    7， 定义一个方法，将成绩作为参数输入，返回等级(A,B,C)。书写程序不停的从控制台输入成绩，对应输出等级。输入0则退出。
    8， 定义一个方法，参数为文件名称，返回文件名称的后缀。
    9， 编写java程序,打印100以内的所有3或7的倍数,并打印所有符合条件数字之和;
    10， * 编写java程序,如果一个数等于其所有因子之和,我们就称这个数为"完数",例如 6的因子为1,2,3 	6=1+2+3   6就是一个完数.请编程打印出1000以内所有的完数;
    11， 编写java程序,定义一个静态的方法,接收两个整数数组,使用循环将两个数组合并成一个数组,并返回处理结果;
    12， * 编写java程序,去除数组{1,3,1,4,2,3,6,1,5}中的重复项,存入一个新的数组,并从大到小排序.  (没去重)
    13， 定义一个方法根据给定的数组大小，使用随机数完成数组的填充，并返回填充完成后的数组
    14， 定义一个方法，参数为一个数组，完成对此数组的排序。

     */

    @Test
    public void Test01(){
        // 1， 创建两个变量a、b，给它们赋值，书写代码，将a，b的值交换。
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入第一个数："); Integer a = scanner.nextInt();
        System.out.print("请输入第二个数："); Integer b = scanner.nextInt();
        System.out.println("第一个数："+a);
        System.out.println("第二个数："+b);
        int num = b;
        a=b;
        b=num;
        System.out.println("交换后，第一个数："+a);
        System.out.println("交换后，第二个数："+b);
    }

    @Test
    public  void Test02(){
        // 2， 给你一个年份，判断该年份是不是闰年。
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入年份："); Integer year = scanner.nextInt();
        System.out.println(year%4==0 && year%100!=0 ? (year+"是闰年。"):(year+"不是闰年。"));
    }

    @Test
    public  void Test03(){
        // 3， 从控制台上输入两个数，将较大的数输出。
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入第一个数："); Integer a = scanner.nextInt();
        System.out.print("请输入第二个数："); Integer b = scanner.nextInt();
        System.out.println("第一个数："+a);
        System.out.println("第二个数："+b);
        System.out.println(a>b?"更大的数："+a:"更大的数："+b);
    }

    @Test
    public  void Test04(){
        // 4， 求1-100的累加值和。
        Integer sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        System.out.println("1-100累加和的值："+sum);
    }
    @Test
    public  void Test05(){
        // 5， 求1-10的累乘
        Integer sum = 1;
        for (int i = 2; i <= 10; i++) {
            sum*=i;
        }
        System.out.println("1-10累乘的值："+sum);
    }
    @Test
    public  void Test06(){
        // 6， 输出1000以内的素数
        for (int i = 1; i <= 1000; i++) {
            for (int j = 2; j < i; j++) {
                if (!(i%j == 0)){
                    System.out.println(i);
                    break;
                }
            }

        }
    }
    @Test
    public  void Test07(){
        // 7， 定义一个方法，将成绩作为参数输入，返回等级(A,B,C)。书写程序不停的从控制台输入成绩，对应输出等级。输入0则退出。
        Scanner scanner = new Scanner(System.in);
        Boolean isContiune = true;
        while (isContiune){
            System.out.print("请输入功能代码：");Integer num = scanner.nextInt();
            switch (num){
                case 0:
                    System.out.println("程序结束");
                    isContiune = false;
                    break;
                default:
                    System.out.print("请输入分数：");Integer score = scanner.nextInt();
                    if(score >= 85){
                        System.out.println("A等级");
                    }else if (score>=60){
                        System.out.println("B等级");
                    }else {
                        System.out.println("C等级");
                    }
                    break;
            }
        }
    }

    @Test
    public  void Test08(){
        // 8， 定义一个方法，参数为文件名称，返回文件名称的后缀。
        System.out.println(Test08StaticMethod("五五开"));
    }

    public  static String Test08StaticMethod(String methodHeader){
        String methodName = methodHeader+".py";
        System.out.println(methodName);
        return methodName.substring(methodName.lastIndexOf("."),methodName.length());
    }

    @Test
    public void Test09(){
        // 9， 编写java程序,打印100以内的所有3或7的倍数,并打印所有符合条件数字之和;
        Integer sum = 0;
        for (int i = 3; i <= 99; i++) {
            if (i%3==0 || i%7==0){
                sum+=i;
            }
        }
        System.out.println("和："+sum);
    }

    @Test
    public void Test10(){
        // 10， 编写java程序,如果一个数等于其所有因子之和,我们就称这个数为"完数",例如 6的因子为1,2,3 	6=1+2+3   6就是一个完数.请编程打印出1000以内所有的完数;
        Integer num = 0;
        for (int i = 3; i <= 1000; i++) {
            Integer sum = 0;
            for (int j = 2; j < i; j++) {
                if (i%j==0 ){
                    sum+=j;
                }
                if (sum==i){
                    num=i;
                }
            }
        System.out.println(+num);
        }
    }

    @Test
    public void Test11(){
        // 11， 编写java程序,定义一个静态的方法,接收两个整数数组,使用循环将两个数组合并成一个数组,并返回处理结果;

        int[] arr01={1,2,3};
        int[] arr02={4,5,6,7};
        System.out.println(Arrays.toString(Test11StaticMethod(arr01,arr02)));

    }
    public static int[] Test11StaticMethod(int[] arr01, int[] arr02){

        //思路：合成数组 长度 = 数组01长度 + 数组02长度
        /*
        两个数组，两个循环0
            1.第1个循环，遍历第一个数组。合成数组从0开始，第一个每取出一个元素赋值给合成数组，合成数组角标自增1，与此同时，数组一也开始进入下次循环。
            2.第2个循环，遍历第二个数组。合成数组角标从第一个数组的length开始，其余同上。
         */

        int[] arrSum = new int[arr01.length+arr02.length];

        Integer arrSumStartIndex = 0;
        for (int arr01Index = 0; arr01Index < arr01.length; arr01Index++) {
            arrSum[arrSumStartIndex++] = arr01[arr01Index];
        }
        Integer arrSumSecondIndex = arr01.length;
        for (int arr02Index = 0; arr02Index < arr02.length; arr02Index++) {
            arrSum[arrSumSecondIndex++] = arr02[arr02Index];
        }
        return  arrSum;
    }

    @Test
    public void Test12(){
        // 12.编写java程序,去除数组{1,3,1,4,2,3,6,1,5}中的重复项,存入一个新的数组,并从大到小排序.

        int[] arrBefor={1,3,1,4,2,3,6,1,5};
        Arrays.sort(arrBefor);
        System.out.println("初始数组："+Arrays.toString(arrBefor));

        int[] arrNow= new int[arrBefor.length];

        int arrBeforeLastIndex = arrBefor.length-1;
        int arrNowStartIndex = 0;
        while (arrNowStartIndex<arrNow.length){
            arrNow[arrNowStartIndex++] = arrBefor[arrBeforeLastIndex--];
        }
        System.out.println("大到小排序数组："+Arrays.toString(arrNow));
    }

    @Test
    public void Test13(){
        // 13， 定义一个方法根据给定的数组大小，使用随机数完成数组的填充，并返回填充完成后的数组

        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数组长度：");Integer length = scanner.nextInt();
        int[] arr = new int[length] ;

        for (int i = 0; i < arr.length; i++) {
            arr[i] = new Random().nextInt(10000);
        }
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void Test14(){
        // 14， 定义一个方法，参数为一个数组，完成对此数组的排序。
        int[] arr = {5,9,3,7,5,777,8,6,56,1,0};
        System.out.println(Arrays.toString(Test14StaticMethod(arr)));
    }
    public static int[] Test14StaticMethod(int[] arr){
         Arrays.sort(arr);
         return arr;
    }


}
